home *** CD-ROM | disk | FTP | other *** search
/ The X-Philes (2nd Revision) / The X-Philes Number 1 (1995).iso / xphiles / hp48_2 / sim1 < prev    next >
Text File  |  1995-03-31  |  39KB  |  1,179 lines
  1. Article 2593 of comp.sys.handhelds:
  2. Path: en.ecn.purdue.edu!noose.ecn.purdue.edu!samsung!munnari.oz.au!bruce!monu1!vaxc!apm279l
  3. From: apm279l@vaxc.cc.monash.edu.au
  4. Newsgroups: comp.sys.handhelds
  5. Subject: Saturn assembly language debugger
  6. Message-ID: <74583.2753b44c@vaxc.cc.monash.edu.au>
  7. Date: 28 Nov 90 01:57:48 GMT
  8. Organization: Computer Centre, Monash University, Australia
  9. Lines: 1166
  10.  
  11. The following is my "sim1" package. It is for debugging your saturn code
  12. before entry to your 28/48. I use the SASS assembler, so I've only run
  13. SASS-format code through it. It is possible there are a few bugs lurking
  14. around, so don't automatically assume a problem results from something in your
  15. code. Carry is set/cleared according to my understanding of what happens
  16. on the calculator (and correspondence with Alonzo). HOWEVER: it is possible
  17. some other instructions alter the carry, or that my understanding is wrong.
  18. At one stage, it was thought that gosubs alterred carry, I have been told
  19. that this is not the case, and gosubs in this code don't alter carry.
  20.  
  21. I'm sorry I don't have time to make this code cope with more general cases,
  22. but I don't yet. It will work for almost all your code though, and I've
  23. found it quite easy to patch it's output C source to allow for some other
  24. cases anyway. For example, you can make up a C routine to simulate the
  25. effect of a jump to a part of your code which accesses RAM, if you know
  26. what a typical call might do.
  27.  
  28. For more info, see the comments at the start of sim1.c
  29.  
  30. Installation:
  31.  
  32. There are 3 files in this package: SIM1.C, SIM1.H, LABELS.H
  33. I've not tar'd them as they are not too long, and this makes it easier to
  34. unpack on any machine.
  35. All you need to do is compile sim1.c, and run it. You are prompted for
  36. the input file (similar to the source you might feed into SASS), and
  37. an output file. You are then asked if you wish to step through your
  38. programme. If you answer in the affirmative, the output c source will
  39. include calls to a debugging module, and running it will be like running
  40. your code through a debugger.
  41.  
  42. Cheers, and enjoy,
  43.  
  44. Peter      apm279l@vaxc.cc.monash.edu.au
  45.  
  46.  
  47.  
  48.                                        _      __
  49.                                  ,/^._/ ^\   {  \-.
  50.                            ,-/~^/         `-/~     \.
  51.                           (    THE 48 ??!!           }
  52.               ___       /  {     A MERE ABACUS     ,/
  53.           ,//| \ \    /     ~ ~^\  MENTION IT NOT! |
  54.         ,// =|H  \*\             \,-+/^\           }
  55.       ,// = =|  P  \ \                  `-.     _,/
  56.     ,// = = =|\      \ \                   ~v/'~
  57.   ,// = = = =|  \  2   \ \
  58.  // = = = = =|    \  8   \ \
  59. ||= = = = = =|\     \  S | |
  60. ||= = = = = =|= \     \  | |
  61. ||= = = = = =|= = \     \| |
  62. ||= = = = = =|= = = \    | /
  63. ||= = = = = =|= = = = \  ||
  64. ||= = = = = =|= = = = = \||
  65. ||= = = = = =|= = = = = =||
  66. ||= = = = = =|= = = = = =||
  67. ||= = = = =,/ \ = = = = =||
  68. ||= = = =,/     \ = = = =||
  69. ||= = =,/         \ = = =||
  70. ||= =,/             \ = =||
  71. ||=,/                 \ =||
  72. \|/                     \||
  73.  
  74.  
  75.  
  76.  
  77.  
  78. ------------------------ %% BEGINNING OF SIM1.C %% ----------------------------
  79.  
  80.  
  81. /*  SIM1.C: A SATURN TO C CONVERTER... copyright (1990) by Peter Hawkins
  82.  
  83. This programme is hereby placed in the public domain. Not to be sold in
  84. whole or part for financial gain. No liability will be accepted by the
  85. author. Do not remove this copyright notice.
  86.  
  87. Parts of it are not-too-well written, and it produces messy code, but
  88. I don't really care!
  89.  
  90. Peter Hawkins: apm279l@vaxc.cc.monash.edu.au
  91.  
  92. Suggestions/comments/additions welcome.
  93. Flames to: bush@whitehouse.gov
  94.  
  95.  
  96. This version:
  97.                  Long is assumed to be four-byte, so all registers are 2-longs.
  98.                  a,b,c,d,d1,d0,st and p are all 64 bit, but only the relevant
  99.                  nybbles are used.
  100.                  The return-to-RPL address, stack pointer, d and b are
  101.                  used, but are initially set to arbitrary values. A jump to
  102.                  RPL is detected. Other jumps to memory are processed by the
  103.                  routine in labels.h (this allows you to add a table of
  104.                  "known" addresses of ROM subroutines.)
  105.                  The routine will warn you if you jump to RPL without restoring
  106.                  D,B D1 or D0. If you write to memory, this *is not* done,
  107.                  instead, a message is displayed to say what was written and
  108.                  where. Similarly, You are prompted for memory contents when
  109.                  you read from memory *unless* the routine in labels.h detects
  110.                  a read from a "known" location (eg stack).
  111.  
  112.                  The commands sethex and setdec are not implemented yet - all
  113.                  operations are in HEX at this stage. If someone extends this
  114.                  send me a copy. I'd also like copies of any other extensions
  115.                  including additions to the labels.h file. I don't have time to
  116.                  do this stuff myself.
  117.  
  118.                  The hardware status registors are not implemented, nor is IN
  119.                  or OUT; opcodes which use them are ignored.
  120.  
  121.                  The opcodes used are Alonzo's improved set, with one
  122.                  additional command: "show_re[gisters]" which causes the
  123.                  contents of all registers to be printed whenever the programme
  124.                  reaches that point.
  125.  
  126.                  If you select the "printout" mode at the prompt, the source
  127.                  code will behave like a (crudish) debugger. You can step
  128.                  through the "pseudo opcodes" one at a time, or several at a
  129.                  time, alter register contents, and the registors are displayed
  130.                  after each step.
  131.  
  132.                  You've got some self-modifying code? bad luck; won't work
  133.                  sorry - this is a crude debugger - I don't think it's worth
  134.                  allowing for every eventuality at this stage.
  135.  
  136.                  You may want to add to labels.h. Also, the screen functions
  137.                  are set up for a VT100, if you use another sort of terminal,
  138.                  just change the escape sequences (first routines in sim1.h)
  139.  
  140. */
  141.  
  142. #include <stdio.h>
  143. #include <string.h>
  144.  
  145. FILE            *infd, *outfd;
  146. int             inptr = 0,min,max,i,digit,bufptr,dotpos,ret_count=0,print_mode=0;
  147. char            ch,field[4],r1[19],r2[4],buffer[50],label[20];
  148.  
  149. getbuff()
  150. {
  151.   char ch1;
  152.  
  153.   bufptr = 0;
  154.   buffer[bufptr] = 0; /* in case blank line or comment only */
  155.   dotpos = 0;
  156.   while ( (!feof(infd)) && ((ch1=fgetc(infd)) != 10))
  157.   {
  158.     if (ch1 == 59)
  159.     {
  160.       while (fgetc(infd) != 10);
  161.       if (bufptr) break;
  162.     }
  163.     else
  164.     {
  165.       if ((ch1 > 31) || (ch1 == 9)) buffer[bufptr++] = ch1;
  166.       if (ch1 == '.') dotpos = bufptr;
  167.       if( ch1 == ':' )
  168.       {
  169.         fprintf(outfd,"\n");
  170.         buffer[bufptr] = 0;
  171.         fprintf(outfd,"%s\n",buffer);
  172.         if (print_mode) fprintf(outfd,"printf(%c%s\\n%c);\n",34,buffer,34);
  173.         bufptr = 0;
  174.         dotpos = 0;
  175.       }
  176.     }
  177.   }
  178.   while ((bufptr > 0)&&(buffer[bufptr-1] < 33)) bufptr--; /*strip trailing junk */
  179.   buffer[bufptr] = 0; /* terminate string */
  180.   bufptr = 0;
  181. }
  182.  
  183. char gtchar() /* finds & returns to next non-junk char, or end of string */
  184. {
  185.   char ch1;
  186.   ch1 = 1;
  187.   while ( (ch1 != 0) && ((ch1=buffer[bufptr++]) < 33 ));
  188.   return ch1;
  189. }
  190.  
  191. int get_token()
  192. {
  193. #define num_3_tokens 18
  194.     static char token_table3[num_3_tokens][3] =
  195.               { "pop","clr","inc","dec","add","sub","and","rln","rrn",
  196.                 "srn","srb","sln","neg","not","nop","brz","ret","or." };
  197.  
  198. #define num_4_tokens 19
  199.     static char token_table4[num_4_tokens][4] =
  200.               { "move","swap","push","clrb","setb","call","jump","breq",
  201.                 "brne","brgt","brlt","brge","brle","brbc","brbs","brcc",
  202.                 "brcs","brnz","retz"};
  203.  
  204. #define num_5_tokens 11
  205.     static char token_table5[num_5_tokens][5] =
  206.               { "reteq","retne","retgt","retlt","retge","retle","retbc",
  207.                 "retbs","retcc","retcs","retnz"};
  208.  
  209. #define num_7_tokens 3
  210.     static char token_table7[num_7_tokens][7] =
  211.               { "retsetc","retclrc","show_re"};
  212.  
  213.     int pos1,token,i;
  214.  
  215.     pos1 = bufptr;
  216.  
  217.     if (dotpos)
  218.     {
  219.       bufptr = dotpos;
  220.       for (i = 0; i < 4; ++i) field[i] = 0;
  221.       field[0]=buffer[bufptr++];
  222.       if ((buffer[bufptr] > 31) && (field[0] < 58) && (buffer[bufptr] < 58)) field[1] = buffer[bufptr++];
  223.       else if (((field[0] == 'w') && (buffer[bufptr] == 'p')) ||
  224.                ((field[0] == 'x') && (buffer[bufptr] == 's')))
  225.            field[1] = buffer[bufptr++];
  226.       else if (field[0] == 'p')
  227.       {
  228.         i = 1;
  229.         while (buffer[bufptr] > 31) field[i++] = buffer[bufptr++];
  230.       }
  231.     }
  232.     else strcpy(field,"def");
  233.  
  234.     token = -1;
  235.     for (i = 0; i < num_7_tokens; ++i)
  236.       { if (!strncmp(&buffer[pos1],&token_table7[i][0],7)) token =i+num_5_tokens+num_4_tokens+num_3_tokens; }
  237.     if (token >= 0)
  238.     {
  239.       if (!dotpos) bufptr += 7;
  240.       return (token);
  241.     }
  242.     
  243.     for (i = 0; i < num_5_tokens; ++i)
  244.       { if (!strncmp(&buffer[pos1],&token_table5[i][0],5)) token =i+num_4_tokens+num_3_tokens; }
  245.     if (token >= 0)
  246.     {
  247.       if (!dotpos) bufptr += 5;
  248.       return (token);
  249.     }
  250.     
  251.     for (i = 0; i < num_4_tokens; ++i)
  252.       { if (!strncmp(&buffer[pos1],&token_table4[i][0],4)) token = i+num_3_tokens; }
  253.     if (token >= 0)
  254.     {
  255.       if (!dotpos) bufptr += 4;
  256.       return (token);
  257.     }
  258.     
  259.     token = 99;
  260.     for (i = 0; i < num_3_tokens; ++i)
  261.       { if (!strncmp(&buffer[pos1],&token_table3[i][0],3)) token = i; }
  262.     if (!dotpos) bufptr += 3;
  263.     return (token);
  264. }
  265.  
  266.  
  267. main()
  268. {                        
  269.     char            filenm[20],pr_ans;
  270.     int             tokn;
  271.  
  272.     printf("Input file name> ");
  273.     scanf("%s",filenm);
  274.  
  275.     if(!(infd = fopen(filenm,"r")))
  276.     {
  277.         printf("error opening %s as input\n",filenm);
  278.         exit(0);
  279.     }
  280.     printf("Output file name> ");
  281.     scanf("%s",filenm);
  282.     outfd = fdopen(creat(filenm,0),"w");
  283.     printf("Do you want %s to step through? n/y:",filenm);
  284.     scanf("%s",&pr_ans);
  285.     if (pr_ans == 'y' || pr_ans == 'Y') print_mode=1;
  286.  
  287.     fprintf(outfd,"#include %csim1.h%c\n\nmain()\n{\n\n#include%clabels.h%c\nset_pmasks();\n\ncls();\n\n",34,34,34,34);
  288.  
  289.     while (!feof(infd))
  290.     {
  291.       getbuff();
  292.       if (gtchar())
  293.       {
  294.         bufptr--;
  295.         if (print_mode) fprintf(outfd,"getstep(%c%s%c);\n",34,buffer,34);
  296.         switch (tokn = get_token())
  297.         {
  298.         case 0: {fprintf(outfd,"pop();"); break;}
  299.         case 1: {getr1(); fprintf(outfd,"clr(mask_%s,%s);",field,r1); break;}
  300.         case 2: {getr1(); fprintf(outfd,"inc(mask_%s,%s);",field,r1); break;}
  301.         case 3: {getr1(); fprintf(outfd,"dec(mask_%s,%s);",field,r1); break;}
  302.         case 4: {getr1r2(); fprintf(outfd,"add(mask_%s,%s,%s);",field,r1,r2); break;}
  303.         case 5: {getr1r2(); fprintf(outfd,"sub(mask_%s,%s,%s);",field,r1,r2); break;}
  304.         case 6: {getr1r2(); fprintf(outfd,"and(mask_%s,%s,%s);",field,r1,r2); break;}
  305.         case 7: {getr1(); fprintf(outfd,"rln(mask_%s,%s);",field,r1); break;}
  306.         case 8: {getr1(); fprintf(outfd,"rrn(mask_%s,%s);",field,r1); break;}
  307.         case 9: {getr1(); fprintf(outfd,"srn(mask_%s,%s);",field,r1); break;}
  308.         case 10: {getr1(); fprintf(outfd,"srb(mask_%s,%s);",field,r1); break;}
  309.         case 11: {getr1(); fprintf(outfd,"sln(mask_%s,%s);",field,r1); break;}
  310.         case 12: {getr1(); fprintf(outfd,"neg(mask_%s,%s);",field,r1); break;}
  311.         case 13: {getr1(); fprintf(outfd,"not(mask_%s,%s);",field,r1); break;}
  312.         case 14: break;
  313.         case 15: {getr1(); getlbl(); fprintf(outfd,"if (!(%s[0] & mask_%s[0]) || (!(%s[1] & mask_%s[1]))) {carry=1; goto %s;} else carry=0;\n",r1,field,r1,field,label); break;}
  314.         case 16: {fprintf(outfd,"goto goreturn;"); break;}
  315.         case 17: {getr1r2(); fprintf(outfd,"or(mask_%s,%s,%s);",field,r1,r2); break;}
  316.         case 18:
  317.           {
  318.             getr1r2();
  319.             if (!strcmp(r2,"pc")) fprintf(outfd,"return_flag=0;tmp[1]=%s[1]&mask_a[1]; goto jump_mem;",r1);
  320.             else
  321.             {
  322.               if (r1[0] == '@') fprintf(outfd,"input(%c%s%c,mask_%s,%s,%s);",34,field,34,field,&r1[1],r2);
  323.               else if (r2[0] == '@') fprintf(outfd,"output(%c%s%c,mask_%s,%s,%s);",34,field,34,field,r1,&r2[1]);
  324.               else fprintf(outfd,"move(mask_%s,%s,%s);",field,r1,r2);
  325.             }
  326.             break;
  327.           }
  328.         case 19:
  329.           {
  330.             getr1r2();
  331.             if (r1[0] == '@')
  332.             {
  333.               fprintf(outfd,"input(%c%s%c,mask_%s,%s,tmp); ",34,field,34,field,&r1[1]);
  334.               strcpy(r1,"tmp");
  335.             }
  336.             if (r2[0] == '@')
  337.             {
  338.               fprintf(outfd,"input(%c%s%c,mask_%s,tmp,%s); ",34,field,34,field,&r2[1]);
  339.               strcpy(r2,"tmp");
  340.             }
  341.             fprintf(outfd,"swap(mask_%s,%s,%s);",field,r1,r2);
  342.             break;
  343.           }
  344.         case 20: {fprintf(outfd,"push();"); break;}
  345.         case 21: {getr1r2(); fprintf(outfd,"%s[1]=%s[1]&(~(1L<<(%s[1]&mask_1[1])));",r2,r2,r1); break;}
  346.         case 22: {getr1r2(); fprintf(outfd,"%s[1]=%s[1]|(1L<<(%s[1]&mask_1[1]));",r2,r2,r1); break;}
  347.         case 23: {getlbl(); fprintf(outfd,"stack[stkptr--] = 0X%05X; goto %s; ret_%05X:",ret_count,label,ret_count); ret_count++; break;}
  348.         case 24: {getlbl(); fprintf(outfd,"goto %s;",label); break;}
  349.         case 25: {getr1r2(); getlbl(); branch("==",label); break;}
  350.         case 26: {getr1r2(); getlbl(); branch("!=",label); break;}
  351.         case 27: {getr1r2(); getlbl(); branch("> ",label); break;}
  352.         case 28: {getr1r2(); getlbl(); branch("< ",label); break;}
  353.         case 29: {getr1r2(); getlbl(); branch(">=",label); break;}
  354.         case 30: {getr1r2(); getlbl(); branch("<=",label); break;}
  355.         case 31: {getr1r2(); getlbl(); fprintf(outfd,"if ((~%s[1])&(1L<<(%s[1]&mask_1[1]))) {carry=1; goto %s;} else carry=0;",r2,r1,label); break;}
  356.         case 32: {getr1r2(); getlbl(); fprintf(outfd,"if(%s[1]&(1L<<(%s[1]&mask_1[1]))) {carry=1; goto %s;} else carry=0;",r2,r1,label); break;}
  357.         case 33: {getlbl(); fprintf(outfd,"if (!carry) goto %s;",label); break;}
  358.         case 34: {getlbl(); fprintf(outfd,"if (carry) goto %s;",label); break;}
  359.         case 35: {getr1(); getlbl(); fprintf(outfd,"if ((%s[0]&mask_%s[0])||(%s[1]&mask_%s[1])) {carry=1; goto %s;} else carry=0;",r1,field,r1,field,label); break;}
  360.         case 36: {getr1(); fprintf(outfd,"if (!(%s[0] & mask_%s[0]) || !(%s[1] & mask_%s[1]))) {carry=1; goto %s;} else carry=0;",r1,field,r1,field); break;}
  361.         case 37: {getr1r2(); branch("==","goreturn"); break;}
  362.         case 38: {getr1r2(); branch("!=","goreturn"); break;}
  363.         case 39: {getr1r2(); branch("> ","goreturn"); break;}
  364.         case 40: {getr1r2(); branch("< ","goreturn"); break;}
  365.         case 41: {getr1r2(); branch(">=","goreturn"); break;}
  366.         case 42: {getr1r2(); branch("<=","goreturn"); break;}
  367.         case 43: {getr1r2(); fprintf(outfd,"if ((~%s[1])&(1L<<(%s[1]&mask_1[1]))) {carry=1; goto goreturn;} else carry=0;",r2,r1); break;}
  368.         case 44: {getr1r2(); fprintf(outfd,"if (%s[1]&(1L<<(%s[1]&mask_1[1]))) {carry=1; goto goreturn;} else carry=0;",r2,r1); break;}
  369.         case 45: {fprintf(outfd,"if (!carry) goto goreturn;"); break;}
  370.         case 46: {fprintf(outfd,"if (carry) goto goreturn;"); break;}
  371.         case 47: {getr1(); fprintf(outfd,"if ((%s[0] & mask_%s[0])||(%s[1] & mask_%s[1])) {carry=1; goto goreturn;} else carry=0;",r1,field,r1,field); break;}
  372.         case 48: {fprintf(outfd,"carry=1; goto goreturn;"); break;}
  373.         case 49: {fprintf(outfd,"carry=0; goto goreturn;"); break;}
  374.         case 50: {fprintf(outfd,"printf(%c\\n%c); show_regs();",34,34); break;}
  375.         default: fprintf(outfd,"printf(%cUnknown operation: %s\\n%c);",34,buffer,34);
  376.         }
  377.       if (!print_mode) fprintf(outfd,"%c/* %s */\n",9,buffer);
  378.       }
  379.     }
  380.  
  381.     if (ret_count)
  382.     {
  383.       fprintf(outfd,"\n\ngoreturn: switch(stack[++stkptr] & mask_a[1])\n  {\n");
  384.       for (i = 0;i < ret_count; ++i) fprintf(outfd,"    case 0X%05X: goto ret_%05X;\n",i,i);
  385.       fprintf(outfd,"    case 0xfffff: {printf(%cERROR: you've pushed/popped return stack\\n%c); exit(0);}\n",34,34);
  386.       fprintf(outfd,"  }\n\n");
  387.     }
  388.   
  389.     fprintf(outfd,"}\n");
  390.     fflush(outfd);
  391.     fclose(outfd);
  392.     fclose(infd);
  393. }
  394.  
  395. getr1()
  396. {
  397.  int j;
  398.  char ch1;
  399.  
  400.  for (j = 0; j < 4; j++) r1[j] = 0;
  401.  ch1=gtchar();
  402.  for (j = 0; ((ch1 != ',') && (j < 3)); j++) {r1[j] = ch1; ch1=gtchar();}
  403. }
  404.  
  405. getr1r2()
  406. {
  407.   int j,k;
  408.   char ch1;
  409.  
  410.   for (j = 0; j < 19; j++) r1[j] = 0;
  411.   for (j = 0; j < 4 ; j++) r2[j] = 0;
  412.   ch1=gtchar();
  413.   for (j = 0; ch1 != ','; j++) {r1[j] = ch1; ch1=gtchar();}
  414.  
  415.   if (r1[0] < 58) /* constant (not register) */
  416.   {
  417.     if ( (r1[0] == '$') || (r1[0] == '#') ) fprintf(outfd,"constmp(mask_%s,0x%sL); ",field,&r1[1]);
  418.     else fprintf(outfd,"constmp(mask_%s,%sL); ",field,r1);
  419.     strcpy(r1,"tmp");
  420.     r1[3] = 0;
  421.   }
  422.  
  423.   ch1=gtchar();
  424.   for (j = 0; ((ch1 > 0) && (ch1 != ',') && (j < 3)); j++) {r2[j] = ch1; ch1=gtchar();}
  425. }
  426.  
  427. getlbl()
  428. {
  429.   int lblptr;
  430.   char ch1;
  431.   if ((ch1 = gtchar()) == 64)
  432.   {
  433.     strcpy(label,"_at_");
  434.     lblptr = 4;
  435.   }
  436.   else
  437.   {
  438.     lblptr = 0;
  439.     bufptr--;
  440.   }
  441.   strcpy(&label[lblptr],&buffer[bufptr]);
  442. }
  443.  
  444.  
  445. branch( char *condit, char *lbl)
  446. {
  447.   if (!strcmp(condit,"=="))
  448.   {
  449.     fprintf(outfd,"if (((%s[0]&mask_%s[0])%s(%s[0]&mask_%s[0]))&&",r1,field,condit,r2,field);
  450.     fprintf(outfd,"((%s[1]&mask_%s[1])%s(%s[1]&mask_%s[1]))) ",r1,field,condit,r2,field);
  451.   }
  452.   else if (!strcmp(condit,"!="))
  453.   {
  454.     fprintf(outfd,"if (((%s[0]&mask_%s[0])%s(%s[0]&mask_%s[0]))||",r1,field,condit,r2,field);
  455.     fprintf(outfd,"((%s[1]&mask_%s[1])%s(%s[1]&mask_%s[1]))) ",r1,field,condit,r2,field);
  456.   }
  457.   else if ((!strcmp(condit,">="))||(!strcmp(condit,"<=")))
  458.   { /* ruddy heck!! what a test!! any better ideas???? */
  459.     fprintf(outfd,"if ((((mask_%s[0]) && ((%s[0]&mask_%s[0])%1s(%s[0]&mask_%s[0])))||",field,r1,field,condit,r2,field);
  460.     fprintf(outfd,"((!mask_%s[0]) && ((%s[1]&mask_%s[1])%1s(%s[1]&mask_%s[1])))) ",field,r1,field,condit,r2,field);
  461.     fprintf(outfd,"|| (((%s[0]&mask_%s[0])==(%s[0]&mask_%s[0]))&&",r1,field,r2,field);
  462.     fprintf(outfd,"((%s[1]&mask_%s[1])==(%s[1]&mask_%s[1])))) ",r1,field,r2,field);
  463.   }
  464.   else
  465.   {
  466.     fprintf(outfd,"if (((mask_%s[0]) && ((%s[0]&mask_%s[0])%s(%s[0]&mask_%s[0])))||",field,r1,field,condit,r2,field);
  467.     fprintf(outfd,"((!mask_%s[0]) && ((%s[1]&mask_%s[1])%s(%s[1]&mask_%s[1])))) ",field,r1,field,condit,r2,field);
  468.   }
  469.   fprintf(outfd,"{carry=1; goto %s;} else carry=0;",lbl);
  470. }
  471.  
  472.  
  473. -------------------------- %% END OF SIM1.C %% --------------------------------
  474.  
  475. ------------------------ %% BEGINNING OF SIM1.H %% ----------------------------
  476.  
  477. #include <stdio>
  478. #include <string.h>
  479. #include <stdlib>
  480.  
  481. #define STRTYP 0x02a2c
  482. #define REATYP 0x02933
  483. #define IMCTYP 0x02c96
  484. #define ALGTYP 0x02ab8
  485. #define PRGTYP 0x02d9d
  486. #define NAMTYP 0x02e48
  487. #define LOCTYP 0x02e67
  488. #define BINTYP 0x02a4e
  489.  
  490.  
  491. #define d0_init  0x000e9e52 /* any number, hopefully not required */
  492. #define d1_init  0x000e9e54 /* top of display_stack */
  493. #define st_init  0x00000000
  494. #define b_init   0x76768576
  495. #define d_init   0x29004976
  496.  
  497. /*now define contents of "known" locations (ie @d0, @d1...) */
  498. #define RPL      0x000e9e53      /* address of next RPL ins */
  499. #define ST0      (d1_init+0x100) /* pointer to stack level 0 */
  500. #define ST1      (ST0 + 0x100)
  501. #define ST2      (ST1 + 0x100)
  502. #define ST3      (ST2 + 0x100)
  503. #define ST4      (ST3 + 0x100)
  504.  
  505. /* now a few aliases */
  506. #define mask_pa mask_p10
  507. #define mask_pb mask_p11
  508. #define mask_pc mask_p12
  509. #define mask_pd mask_p13
  510. #define mask_pe mask_p14
  511. #define mask_pf mask_p15
  512.  
  513. typedef unsigned long reg_t[2];
  514.  
  515. reg_t tmp;
  516. reg_t a,b={0,b_init},c,d={0,d_init};
  517. reg_t r0,r1,r2,r3,r4;
  518. reg_t d0={0,d0_init},d1={0,d1_init},pc={0,0},st={0,st_init},p={0,0};
  519. unsigned char  carry=0,stkptr=6,return_flag;
  520. unsigned long  stack[7]={0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff};
  521.  
  522. /* ------------------------------------------------------------------------- */
  523. /*                      Screen functions for vt100                           */
  524.  
  525. cls() /* clear screen */
  526. {
  527.   printf("%c[2J",27);
  528. }
  529.  
  530. ebl() /* erase bottom line */
  531. {
  532.   bos();
  533.   printf("%c[2K",27);
  534. }
  535.  
  536. tos() /* curser to top of screen */
  537. {
  538.   printf("%c[H",27);
  539. }
  540.  
  541. bos() /* curser to bottom of screen */
  542. {
  543.   printf("%c[23;0H",27);
  544. }
  545.  
  546. bold() /* bold text */
  547. {
  548.   printf("%c[1m",27);
  549. }
  550.  
  551. norm() /* normal text */
  552. {
  553.   printf("%c[0m",27);
  554. }
  555.  
  556. /* ------------------------------------------------------------------------- */
  557.  
  558.  
  559. reg_t mask_1  = {0x00000000, 0x0000000f};
  560. reg_t mask_2  = {0x00000000, 0x000000ff};
  561. reg_t mask_3  = {0x00000000, 0x00000fff};
  562. reg_t mask_4  = {0x00000000, 0x0000ffff};
  563. reg_t mask_5  = {0x00000000, 0x000fffff};
  564. reg_t mask_6  = {0x00000000, 0x00ffffff};
  565. reg_t mask_7  = {0x00000000, 0x0fffffff};
  566. reg_t mask_8  = {0x00000000, 0xffffffff};
  567. reg_t mask_9  = {0x0000000f, 0xffffffff};
  568. reg_t mask_10 = {0x000000ff, 0xffffffff};
  569. reg_t mask_11 = {0x00000fff, 0xffffffff};
  570. reg_t mask_12 = {0x0000ffff, 0xffffffff};
  571. reg_t mask_13 = {0x000fffff, 0xffffffff};
  572. reg_t mask_14 = {0x00ffffff, 0xffffffff};
  573. reg_t mask_15 = {0x0fffffff, 0xffffffff};
  574. reg_t mask_16 = {0xffffffff, 0xffffffff};
  575. reg_t mask_w  = {0xffffffff, 0xffffffff};
  576. reg_t mask_a  = {0x00000000, 0x000fffff};
  577. reg_t mask_x  = {0x00000000, 0x00000fff};
  578. reg_t mask_s  = {0xf0000000, 0x00000000};
  579. reg_t mask_m  = {0x0fffffff, 0xfffff000};
  580. reg_t mask_b  = {0x00000000, 0x000000ff};
  581. reg_t mask_xs = {0x00000000, 0x00000f00};
  582. reg_t mask_def= {0x00000000, 0x000fffff}; /* default - non .a defaults should be OK */
  583. reg_t mask_p,mask_wp,mask_p1,mask_p2,mask_p3,mask_p4,mask_p5,mask_p6;
  584. reg_t mask_p7,mask_p8,mask_p9,mask_p10,mask_p11,mask_p12,mask_p13;
  585. reg_t mask_p14,mask_p15,mask_p16;
  586.  
  587. set_pmasks()
  588. {
  589.   short int i;
  590.   p[1] &= mask_1[1];
  591.   p[0] = 0;
  592.   if (p[1] < 8)
  593.   {
  594.     mask_p[0]  = 0x00000000;
  595.     mask_p[1] = 0x0000000f;
  596.     mask_wp[0] = 0x00000000;
  597.     mask_wp[1] = 0x0000000f;
  598.     for (i = 0; i < p[1]; ++i)
  599.     {
  600.       mask_p[1] == (mask_p[1] << (4*i));
  601.       mask_wp[1] |= mask_p[1];
  602.     }
  603.   }
  604.   else
  605.   {
  606.     mask_p[0]  = 0x0000000f;
  607.     mask_p[1]  = 0x00000000;
  608.     mask_wp[0] = 0x0000000f;
  609.     mask_wp[1] = 0x00000000;
  610.     for (i = 0; i < p[1]-8; ++i)
  611.     {
  612.       mask_p[0] == (mask_p[0] << (4*i));
  613.       mask_wp[0] |= mask_p[0];
  614.     }
  615.   }
  616.   mask_n(mask_p1,1);
  617.   mask_n(mask_p2,2);
  618.   mask_n(mask_p3,3);
  619.   mask_n(mask_p4,4);
  620.   mask_n(mask_p5,5);
  621.   mask_n(mask_p6,6);
  622.   mask_n(mask_p7,7);
  623.   mask_n(mask_p8,8);
  624.   mask_n(mask_p9,9);
  625.   mask_n(mask_p10,10);
  626.   mask_n(mask_p11,11);
  627.   mask_n(mask_p12,12);
  628.   mask_n(mask_p13,13);
  629.   mask_n(mask_p14,14);
  630.   mask_n(mask_p15,15);
  631.   mask_n(mask_p16,16);
  632. }
  633.  
  634. mask_n(reg,n)
  635. reg_t reg;
  636. int n;
  637. {
  638.   reg_t tmp1;
  639.   int i;
  640.  
  641.   reg[0] = 0;
  642.   reg[1] = 0;
  643.   if (p[1] < 8) 
  644.   {
  645.     for (i = p[1]; (i < 8)&&(i<(n+p[1])); ++i) reg[1] |= (0xf << (4*i));
  646.     if (i < (n+p[1])) {for (i = 0; (i < 8)&&(i<(n+p[1]-8)); ++i) reg[0] |= (0xf<< (4*i));}
  647.   }  
  648.   else
  649.   {
  650.     for (i = p[1]; (i < 8)&&(i<(n+p[1])); ++i) reg[0] |= (0xf << (4*i));
  651.   }
  652. }
  653.  
  654.  
  655. move(  mask, reg1, reg2)
  656. reg_t  mask, reg1, reg2;
  657. {
  658.   short int i;
  659.   if (®1[0]==&pc[0]) printf("Ignoring <move pc,register> instruction...\n");
  660.   else
  661.   {
  662.     if ((&mask[0]==&mask_def[0]) && 
  663.        (  (®1[0]==&r0[0])||(®2[0]==&r0[0])
  664.         ||(®1[0]==&r1[0])||(®2[0]==&r1[0])
  665.         ||(®1[0]==&r2[0])||(®2[0]==&r2[0])
  666.         ||(®1[0]==&r3[0])||(®2[0]==&r3[0])
  667.         ||(®1[0]==&r4[0])||(®2[0]==&r4[0]) )) {mask[0]=mask_w[0]; mask[1]=mask_w[1];}
  668.       
  669.     for (i = 0; i < 2; ++i) reg2[i] = (reg2[i] & (~mask[i])) | (reg1[i] & mask[i]);
  670.     if (®2[0]==&p[0]) set_pmasks();
  671.   }
  672. }
  673.  
  674. swap(  mask, reg1, reg2)
  675. reg_t  mask, reg1, reg2;
  676. {
  677.   short int i;
  678.   reg_t tmp1;
  679.   if ((&mask[0]==&mask_def[0]) && 
  680.      (  (®1[0]==&r0[0])||(®2[0]==&r0[0])
  681.       ||(®1[0]==&r1[0])||(®2[0]==&r1[0])
  682.       ||(®1[0]==&r2[0])||(®2[0]==&r2[0])
  683.       ||(®1[0]==&r3[0])||(®2[0]==&r3[0])
  684.       ||(®1[0]==&r4[0])||(®2[0]==&r4[0]) )) {mask[0]=mask_w[0]; mask[1]=mask_w[1];}
  685.   for (i = 0; i < 2; ++i)
  686.   {
  687.     tmp1[i] = (reg2[i] & (~mask[i])) | (reg1[i] & mask[i]);
  688.     reg1[i] = (reg1[i] & (~mask[i])) | (reg2[i] & mask[i]);
  689.     reg2[i] = tmp1[i];
  690.   }
  691.   if (®2[0]==&p[0]) set_pmasks();
  692. }
  693.  
  694. push()
  695. {
  696.   stack[stkptr--] = c[0] & mask_a[0];
  697. }
  698.  
  699. pop()
  700. {
  701.   c[0] = ((c[0] & (~mask_a[0])) | (stack[stkptr++] & mask_a[0]));
  702. }
  703.  
  704. clr(   mask, reg1)
  705. reg_t  mask, reg1;
  706. {
  707.   short int i;
  708.   for (i = 0; i < 2; i++) reg1[i] &= (~mask[i]);
  709. }
  710.  
  711. and(   mask, reg1, reg2)
  712. reg_t  mask, reg1, reg2;
  713. {
  714.   short int i;
  715.   for (i = 0; i < 2; i++) reg2[i] = ((reg2[i] & (~mask[i])) | (reg2[i] & mask[i] & reg1[i]));
  716. }
  717.  
  718. or(    mask, reg1, reg2)
  719. reg_t  mask, reg1, reg2;
  720. {
  721.   short int i;
  722.   for (i = 0; i < 2; i++) reg2[i] = ((reg2[i] & (~mask[i])) | ((reg2[i] |reg1[i]) & mask[i]));
  723. }
  724.  
  725. inc(   mask, reg1)
  726. reg_t  mask, reg1;
  727. {
  728.   reg_t tmp1;
  729.   tmp1[0] = 0;
  730.   tmp1[1] = 1;
  731.   while (tmp1[1] && (!(tmp1[1] & mask[1]))) (tmp1[1] << 4);
  732.   if (!tmp1[1])
  733.   {
  734.     tmp1[0] = 1;
  735.     while (tmp1[0] && (!(tmp1[0] & mask[0]))) (tmp1[0] << 4);
  736.   }
  737.   add(mask,tmp1,reg1);
  738. }
  739.  
  740. dec(   mask, reg1)
  741. reg_t  mask, reg1;
  742. {
  743.   reg_t tmp1;
  744.   tmp1[0] = 0;
  745.   tmp1[1] = 1;
  746.   while (tmp1[1] && (!(tmp1[1] & mask[1]))) (tmp1[1] << 4);
  747.   if (!tmp1[1])
  748.   {
  749.     tmp1[0] = 1;
  750.     while (tmp1[0] && (!(tmp1[0] & mask[0]))) (tmp1[0] << 4);
  751.   }
  752.   sub(mask,tmp1,reg1);
  753. }
  754.  
  755.  
  756. add(   mask, reg1, reg2)
  757. reg_t  mask, reg1, reg2;
  758. {
  759.   unsigned long t;
  760.   reg2[1] += (reg1[1] & mask[1]);
  761.   if ( (((reg2[1] >> 4) + (reg1[1] & mask[1])) >> 4) & 0xf0000000 )
  762.   {
  763.     t = reg2[0];
  764.     reg2[0] += ( (reg1[0]+1) & mask[0] );
  765.     carry = (t+((reg1[0]+1) & mask[0]) != reg2[0]);
  766.   }
  767.   else
  768.   {
  769.     t = reg2[0];
  770.     reg2[0] += ( reg1[0] & mask[0] );
  771.     carry = (t+(reg1[0] & mask[0]) != reg2[0]);
  772.   }
  773.   if (®2[0]==&p[0]) set_pmasks();
  774. }
  775.  
  776.  
  777. sub(   mask, reg1, reg2)
  778. reg_t  mask, reg1, reg2;
  779. {
  780.   unsigned long t;
  781.   reg2[1] -= (reg1[1] & mask[1]);
  782.   if ((reg2[1] & mask[1]) < (reg1[1] & mask[1]))
  783.   {
  784.     t = reg2[0];
  785.     reg2[0] -= ( (reg1[0]+1) & mask[0] );
  786.     carry = (t-((reg1[0]+1) & mask[0]) != reg2[0]);
  787.   }
  788.   else
  789.   {
  790.     t = reg2[0];
  791.     reg2[0] -= ( reg1[0] & mask[0] );
  792.     carry = (t-(reg1[0] & mask[0]) != reg2[0]);
  793.   }
  794.   if (®2[0]==&p[0]) set_pmasks();
  795. }
  796.  
  797. not(   mask, reg1)
  798. reg_t  mask, reg1;
  799. {
  800.   carry = 0;
  801.   reg1[0] = (reg1[0] & (~mask[0])) | ((~reg1[0]) & mask[0]);
  802.   reg1[1] = (reg1[1] & (~mask[1])) | ((~reg1[1]) & mask[1]);
  803. }
  804.  
  805. neg(   mask, reg1)
  806. reg_t  mask, reg1;
  807. {
  808.   not(mask,reg1);
  809.   dec(mask,reg1);
  810. }
  811.  
  812. rrn(   mask, reg1)
  813. reg_t  mask, reg1;
  814. {
  815.   long i,store;
  816.   if (mask[1])
  817.   {
  818.     for (i=0xfL; (!(mask[1] & i)); i = i << 4);
  819.     store = reg1[1] & i;
  820.   }
  821.   else
  822.   {
  823.     for (i=0xfL; (!(mask[0] & i)); i = i < 4);
  824.     store = reg1[0] & i;
  825.   }
  826.   while (store > 0xfL) store = store >> 4;
  827.  
  828.   srn(mask,reg1);
  829.   if (store)
  830.   {
  831.     if (mask[0])
  832.     {
  833.       for (i=0xf0000000L; (!(mask[0] & i)); i = i >> 4);
  834.       while (!(store & i)) store = store << 4;
  835.       reg1[0] |= store;
  836.     }
  837.     else
  838.     {
  839.       for (i=0xf0000000L; (!(mask[1] & i)); i = i >> 4);
  840.       while (!(store & i)) store = store << 4;
  841.       reg1[1] |= store;
  842.     }
  843.   }
  844. }
  845.  
  846. rln(   mask, reg1)
  847. reg_t  mask, reg1;
  848. {
  849.   long i,store;
  850.   if (mask[0])
  851.   {
  852.     for (i=0xf0000000L; (!(mask[0] & i)); i = i >> 4);
  853.     store = reg1[0] & i;
  854.   }
  855.   else
  856.   {
  857.     for (i=0xf0000000L; (!(mask[1] & i)); i = i >> 4);
  858.     store = reg1[1] & i;
  859.   }
  860.   while (store > 0xfL) store = store >> 4;
  861.  
  862.   sln(mask,reg1);
  863.   if (store)
  864.   {
  865.     if (mask[1])
  866.     {
  867.       for (i=0xfL; (!(mask[1] & i)); i = i << 4);
  868.       while (!(store & i)) store = store << 4;
  869.       reg1[1] |= store;
  870.     }
  871.     else
  872.     {
  873.       for (i=0xfL; (!(mask[0] & i)); i = i << 4);
  874.       while (!(store & i)) store = store << 4;
  875.       reg1[0] |= store;
  876.     }
  877.   }
  878. }
  879.  
  880. srn(   mask, reg1)
  881. reg_t  mask, reg1;
  882. {
  883.   reg_t tmp1;
  884.   tmp1[1] = (((reg1[1] & mask[1]) >> 4L)|((reg1[0] & 0xfL) << 28L)) & mask[1];
  885.   tmp1[0] =   (reg1[0] & mask[0]) >> 4L;
  886.   reg1[0] = (reg1[0] & (~mask[0])) | (tmp1[0] & mask[0]);
  887.   reg1[1] = (reg1[1] & (~mask[1])) | (tmp1[1] & mask[1]);
  888. }
  889.  
  890. srb(   mask, reg1)
  891. reg_t  mask, reg1;
  892. {
  893.   reg_t tmp1;
  894.   tmp1[1] = (((reg1[1] & mask[1]) >> 1L)|((reg1[0] & 0x1L) << 31L)) & mask[1];
  895.   tmp1[0] =   (reg1[0] & mask[0]) >> 1L;
  896.   reg1[0] = (reg1[0] & (~mask[0])) | (tmp1[0] & mask[0]);
  897.   reg1[1] = (reg1[1] & (~mask[1])) | (tmp1[1] & mask[1]);
  898. }
  899.  
  900. sln(   mask, reg1)
  901. reg_t  mask, reg1;
  902. {
  903.   reg_t tmp1;
  904.   tmp1[1] =  ((reg1[1] & mask[1]) << 4L) & mask[1];
  905.   tmp1[0] = (((reg1[0] & mask[0]) << 4L)|((reg1[1] & 0xf0000000L) >> 28L)) & mask[0];
  906.   reg1[0] = (reg1[0] & (~mask[0])) | (tmp1[0] & mask[0]);
  907.   reg1[1] = (reg1[1] & (~mask[1])) | (tmp1[1] & mask[1]);
  908. }
  909.  
  910.  
  911. constmp(mask, cons)
  912. reg_t mask;
  913. long cons;
  914. {
  915.   short int i;
  916.   i = 0;
  917.   while ((1 << i) && !((1 << i) & mask[1])) i += 4;
  918.   if (!(1 << (i-8))) while ((1 << (i-8)) && !((1 << (i-8)) & mask[0])) i += 4;
  919.   tmp[1] = (mask[1] & ( cons <<   i   ));
  920.   tmp[0] = (mask[0] & ( cons >> (8-i) ));
  921. }
  922.  
  923. show_regs()
  924. {
  925.   int i;
  926.   char strng1[17],strng2[17];
  927.   printf("-------------------------------------------------------------------------------\n");
  928.   printf("| a=%08X%08X b=%08X%08X c=%08X%08X d=%08X%08X |\n",a[0],a[1],b[0],b[1],c[0],c[1],d[0],d[1]);
  929.   printf("| d0 = %05X,     d1 = %05X,      status = %04X,      p = %1X,     carry %s |\n",d0[1]&mask_a[1],d1[1]&mask_a[1],st[1]&mask_4[1],p[1],(carry) ? "set  " :"clear");
  930.   printf("-------------------------------------------------------------------------------\n");
  931. }
  932.  
  933. input(fld, mask, reg1, reg2)
  934. reg_t mask, reg1, reg2;
  935. char fld[3];
  936. {
  937.   char instr[17],str1[9],str2[17];
  938.   int i;
  939.  
  940.   if((mask[0]==mask_a[0]) && (mask[1]==mask_a[1])) /* getting an address? */
  941.   {
  942.     switch (reg1[1]&mask_a[1]) /* is it known? */
  943.     {
  944.       case d0_init:         {reg2[1]=(reg2[1] & (~mask[1]))      | (RPL & mask[1]); return; break; }
  945.       case d1_init:         {reg2[1]=(reg2[1] & (~mask[1]))      | (ST0 & mask[1]); return; break; }
  946.       case (5 +d1_init):    {reg2[1]=(reg2[1] & (~mask[1])) | (ST1 &mask[1]); return; break; }
  947.       case (10+d1_init):    {reg2[1]=(reg2[1] & (~mask[1])) | (ST2 & mask[1]); return; break; }
  948.       case (15+d1_init):    {reg2[1]=(reg2[1] & (~mask[1])) | (ST3 & mask[1]); return; break; }
  949.       case (20+d1_init):    {reg2[1]=(reg2[1] & (~mask[1])) | (ST4 & mask[1]); return; break; }
  950.       case ST0:             {intype(mask,reg2,1); return; break;}
  951.       case ST1:             {intype(mask,reg2,1); return; break;}
  952.       case ST2:             {intype(mask,reg2,2); return; break;}
  953.       case ST3:             {intype(mask,reg2,3); return; break;}
  954.       case ST4:             {intype(mask,reg2,4); return; break;}
  955.       case (ST0+5):         {printf("Input from Stack[0]+5: "); break;}
  956.       case (ST0+10):        {printf("Input from Stack[0]+10: "); break;}
  957.       case (ST1+5):         {printf("Input from Stack[1]+5: "); break;}
  958.       case (ST1+10):        {printf("Input from Stack[1]+10: "); break;}
  959.       case (ST2+5):         {printf("Input from Stack[2]+5: "); break;}
  960.       case (ST2+10):        {printf("Input from Stack[2]+10: "); break;}
  961.       case (ST3+5):         {printf("Input from Stack[3]+5: "); break;}
  962.       case (ST3+10):        {printf("Input from Stack[3]+10: "); break;}
  963.       case (ST4+5):         {printf("Input from Stack[4]+5: "); break;}
  964.       case (ST4+10):        {printf("Input from Stack[4]+10: "); break;}
  965.     }
  966.   }
  967.  
  968.   for (i = 0; i < 16; ++i) instr[i] = 48;
  969.   instr[17] = 0;
  970.   for (i = 0; i < 8 && !( (1<<(4*i)) & mask[1]); ++i);
  971.   if (i == 8) for (i = 8;i < 16 & !( (1<<((4*i)-32)) & mask[0]); ++i);
  972.   
  973.   printf("Input [%3s] field (in hex) stored at %05X: ",fld,(reg1[1] & mask_a[1]) );
  974.   scanf("%s",str2);
  975.   printf("\n");
  976.   strncpy(&instr[16-i-strlen(str2)],str2,strlen(str2));
  977.   strncpy(str1,instr,8);
  978.   str1[8]=0;
  979.   reg2[0] = (reg2[0] & (~mask[0])) | (strtoul(str1,NULL,16) & mask[0]);
  980.   reg2[1] = (reg2[1] & (~mask[1])) | (strtoul(&instr[8],NULL,16) & mask[1]);
  981. }
  982.  
  983. output(fld, mask, reg1, reg2)
  984. reg_t mask, reg1, reg2;
  985. char fld[3];
  986. {
  987.   if (mask[0] && mask[1]) printf("[%s] field of @[%05X] <= %x%0x\n",fld,reg2[1]&mask_a[1],reg1[0]&mask[0],reg1[1]&mask[1]);
  988.   else if (mask[0] && !mask[1]) printf("[%s] field of @[%05X] <= %x\n",fld,reg2[1]&mask_a[1],reg1[0]&mask[0]);
  989.   else printf("[%s] field of @[%05X] is now %x\n",fld,reg2[1]&mask_a[1],reg1[1]&mask[1]);
  990. }
  991.  
  992.  
  993. intype(mask,reg2,lvl)
  994. reg_t mask, reg2;
  995. int lvl;
  996. {
  997.   int i;
  998.  
  999.   printf("Input type of object in level %d of display:\n\n    (0)    String\n    (1)    Real\n    (2)    Inline machine code\n    (3)    Algebraic obj\n    (4)    Programme\n    (5)    Global Name\n    (6)    Local Name\n    (7)    Binary Integer\n",lvl);
  1000.  
  1001.   scanf("%d",&i);
  1002.   switch (i)
  1003.   {
  1004.     case 0: {reg2[1]=(reg2[1] & (~mask[1])) | (STRTYP & mask[1]); break;}
  1005.     case 1: {reg2[1]=(reg2[1] & (~mask[1])) | (REATYP & mask[1]); break;}
  1006.     case 2: {reg2[1]=(reg2[1] & (~mask[1])) | (IMCTYP & mask[1]); break;}
  1007.     case 3: {reg2[1]=(reg2[1] & (~mask[1])) | (ALGTYP & mask[1]); break;}
  1008.     case 4: {reg2[1]=(reg2[1] & (~mask[1])) | (PRGTYP & mask[1]); break;}
  1009.     case 5: {reg2[1]=(reg2[1] & (~mask[1])) | (NAMTYP & mask[1]); break;}
  1010.     case 6: {reg2[1]=(reg2[1] & (~mask[1])) | (LOCTYP & mask[1]); break;}
  1011.     case 7: {reg2[1]=(reg2[1] & (~mask[1])) | (BINTYP & mask[1]); break;}
  1012.     default: printf("error, unknown type\n");
  1013.   }
  1014.   printf("\n");
  1015. }
  1016.  
  1017. getstep(char *cmd)
  1018. {
  1019.   char cnt[5];
  1020.   static int step_count=1;
  1021.  
  1022.   printf ("%s\n",cmd);
  1023.   if (!(--step_count))
  1024.   {
  1025.     tos();
  1026.     bold();
  1027.     show_regs();
  1028.     bos();
  1029.     printf("\n%c%c%c clr,set,qui,n-steps: ",9,9,9);
  1030.     norm();
  1031.     scanf("%s",cnt);
  1032.     while ((!strcmp(cnt,"clr"))||(!strcmp(cnt,"set")))
  1033.     {
  1034.       if(!strcmp(cnt,"clr"))
  1035.       {
  1036.         cls();
  1037.         bos();
  1038.         printf ("%s",cmd);
  1039.         printf ("\n");  /* for some reason, I need to do it this way on my term */
  1040.       }
  1041.       else
  1042.       {
  1043.         bold();
  1044.         printf("Enter name of register (a,b,c,d,d0,d1,st,p,car): ");
  1045.         norm();
  1046.         scanf("%s",cnt);
  1047.         ebl();
  1048.         if (!strcmp(cnt,"car"))
  1049.         {
  1050.           bold();
  1051.           printf("Set/Clear? (s/c)");
  1052.           norm();
  1053.           scanf("%c",cnt);
  1054.           if (cnt[0]==115) carry=1; else carry=0;
  1055.         }
  1056.         else if (!strcmp(cnt,"p"))
  1057.         {
  1058.           bold();
  1059.           printf("Enter HEX value (1 nybble): ");
  1060.           norm();
  1061.           scanf("%1x",&p[1]);
  1062.           set_pmasks();
  1063.         }
  1064.         else if (!strcmp(cnt,"st"))
  1065.         {
  1066.           bold();
  1067.           printf("Enter HEX value (4 nybbles): ");
  1068.           norm();
  1069.           scanf("%4x",&st[1]);
  1070.         }
  1071.         else if (!strcmp(cnt,"d0"))
  1072.         {
  1073.           bold();
  1074.           printf("Enter new value (in HEX) (5 nybbles): ");
  1075.           norm();
  1076.           scanf("%5x",&d0[1]);
  1077.         }
  1078.         else if (!strcmp(cnt,"d1"))
  1079.         {
  1080.           bold();
  1081.           printf("Enter new value (in HEX) (5 nybbles): ");
  1082.           norm();
  1083.           scanf("%5x",&d1[1]);
  1084.         }
  1085.         else if (!strcmp(cnt,"a"))
  1086.         {
  1087.           bold();
  1088.           printf("Enter new value (in HEX) (16 nyb incl leading 0s): ");
  1089.           norm();
  1090.           scanf("%16x",&a[0],&a[1]);
  1091.         }
  1092.         else if (!strcmp(cnt,"b"))
  1093.         {
  1094.           bold();
  1095.           printf("Enter new value (in HEX) (16 nyb incl leading 0s): ");
  1096.           norm();
  1097.           scanf("%16x",&b[0],&b[1]);
  1098.         }
  1099.         else if (!strcmp(cnt,"c"))
  1100.         {
  1101.           bold();
  1102.           printf("Enter new value (in HEX) (16 nyb incl leading 0s): ");
  1103.           norm();
  1104.           scanf("%16x",&c[0],&c[1]);
  1105.         }
  1106.         else if (!strcmp(cnt,"d"))
  1107.         {
  1108.           bold();
  1109.           printf("Enter new value (in HEX) (16 nybs incl leading 0s): ");
  1110.           norm();
  1111.           scanf("%16x",&d[0],&d[1]);
  1112.         }
  1113.         else printf("Illegal register name - ignored");
  1114.         printf("\n");
  1115.       }
  1116.       tos();
  1117.       bold();
  1118.       show_regs();
  1119.       bos();
  1120.       printf("\n%c%c%c clr,set,qui,n-steps: ",9,9,9);
  1121.       norm();
  1122.       scanf("%s",cnt);
  1123.     }
  1124.     if (!strcmp(cnt,"qui"))
  1125.     {
  1126.       cls();
  1127.       tos();
  1128.       exit(0);
  1129.     }
  1130.     ebl();
  1131.     step_count=strtol(cnt,NULL,10);
  1132.     if (!step_count) step_count = 1;
  1133.   }
  1134. }
  1135.  
  1136.  
  1137. -------------------------- %% END OF SIM1.H %% --------------------------------
  1138.  
  1139. ---------------------- %% BEGINNING OF LABELS.H %% ----------------------------
  1140.  
  1141. cls();
  1142. bos();
  1143. goto start_prg;
  1144.  
  1145. jmp_at_a: tmp[1] = a[1];
  1146.     return_flag = 0;
  1147.     goto jump_mem;
  1148.  
  1149. jmp_at_c: tmp[1] = c[1];
  1150.     return_flag = 0;
  1151.     goto jump_mem;
  1152.  
  1153. jump_mem:
  1154.  
  1155.   switch (tmp[1]&mask_a[1])
  1156.   {
  1157.     case RPL:
  1158.       {
  1159.         printf("programme returned to RPL\n");
  1160.         if (p) printf("%%%WARNING%%% you have not set p to 0,%c\n",7);
  1161.         if (b[1] != b_init) printf("%%%WARNING%%% you have not restored b,%c\n",7);
  1162.         if (d0[1] != d0_init + 5) printf("%%%WARNING%%% you have not restored d0,%c\n",7);
  1163.         if (d1[1] != d1_init + (d[1]-d_init)*5) printf("%%%WARNING%%% d1 and d are no longer consistent,%c\n",7);
  1164.         break;
  1165.       }
  1166.     default:         printf("programme jumped to memory location %5x\n",tmp[1] & mask_a[1]);
  1167.   }
  1168.   if (!return_flag) exit(0);
  1169.   else printf("%%%WARNING%%% programme continuing without executing routine at%5x%c\n",tmp[1] & mask_a[1],7);
  1170.  
  1171. start_prg:
  1172.  
  1173. /* ------------------------------------------------------------------------- */
  1174.  
  1175.  
  1176. ------------------------- %% END OF PACKAGE %% ------------------------------
  1177.  
  1178.  
  1179.